﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace FGK
{
    class Trojkat : Obiekt
    {
        private Wektor vert1, vert2, vert3, vNormal;
        private bool setN;

        public Trojkat(Wektor v1, Wektor v2, Wektor v3)
        {
            vert1 = v1;
            vert2 = v2;
            vert3 = v3;
            setN = false;
        }

        public Trojkat(Wektor v1, Wektor v2, Wektor v3, Wektor normal)
        {
            vert1 = v1;
            vert2 = v2;
            vert3 = v3;
            vNormal = normal;
            setN = false;
        }


        public Wektor VNormal
        {
            set { vNormal = value;
                    setN = false; }
            get { return vNormal; }
        }

        public Wektor Vert1
        {
            get { return vert1; }
        }
        public Wektor Vert2
        {
            get { return vert2; }
        }
        public Wektor Vert3
        {
            get { return vert3; }
        }

        public Trojkat(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3)
        {
            vert1 = new Wektor(x1, y1, z1);
            vert2 = new Wektor(x2, y2, z2);
            vert3 = new Wektor(x3, y3, z3);
            setN = false;
        }

        public override Wektor normalna(Wektor punkt)
        {
                Wektor vNormal;
                Wektor v1 = vert1 - vert3;
                Wektor v2 = vert1 - vert2;
                vNormal = v2.cross(v1);
                vNormal.normalize();
                return vNormal;   
        }

        public override string ToString()
        {
            return "Trojkat(" + vert1 + "," + vert2 + "," + vert3 + " )" + " normalna: " + vNormal;
        }

        public override Kolor texDiff(Wektor kolizja)
        {
            return material.Diffuse;
        }
        public override Wektor[] brylaOtaczajaca()
        {
            Wektor[] wierzcholki = new Wektor[2];
            wierzcholki[0] = new Wektor();
            wierzcholki[1] = new Wektor();
            wierzcholki[0].X = Math.Min(vert1.X, vert2.X);
            wierzcholki[0].X = Math.Min(wierzcholki[0].X, vert3.X);
            wierzcholki[0].Y = Math.Min(vert1.Y, vert2.Y);
            wierzcholki[0].Y = Math.Min(wierzcholki[0].Y, vert3.Y);
            wierzcholki[0].Z = Math.Min(vert1.Z, vert2.Z);
            wierzcholki[0].Z = Math.Min(wierzcholki[0].Z, vert3.Z);
            wierzcholki[1].X = Math.Max(vert1.X, vert2.X);
            wierzcholki[1].X = Math.Max(wierzcholki[1].X, vert3.X);
            wierzcholki[1].Y = Math.Max(vert1.Y, vert2.Y);
            wierzcholki[1].Y = Math.Max(wierzcholki[1].Y, vert3.Y);
            wierzcholki[1].Z = Math.Max(vert1.Z, vert2.Z);
            wierzcholki[1].Z = Math.Max(wierzcholki[1].Z, vert3.Z);
            return wierzcholki;
        }


        /*public override int IlePrzeciec(Promien r)
        {
            Wektor E2 = vert3 - vert1;
            Wektor E1 = vert2 - vert1;
            Wektor P = r.Kierunek.cross(E2);
            float det = P.dot(E1);
            if (det > 0.00001)
            {
                Wektor T = r.Start - vert1;
                Wektor Q = T.cross(E1);
                float u = P.dot(T) / det;
                if (u > 0.00001)
                {
                    float v = Q.dot(r.Kierunek) / det;
                    if ((v > 0.00001) && (u + v < 1.00001))
                    {
                        r.setOdleglosc(this, (Q.dot(E2) / det));
                        //Console.WriteLine("hit");
                        return 1;
                    }
                }
            }
            return 0;

        }*/


        public override int IlePrzeciec(Promien p)
        {
            Wektor e1 = vert2 - vert1;
            Wektor e2 = vert3 - vert1;
            Wektor h = p.Kierunek.cross(e2);
            float a = e1.dot(h);
            if (a > -0.00001 && a < 0.00001)
                return (0);

            float f = 1 / a;
            Wektor s=p.Start - vert1;
            float u = f * (s.dot( h));

            if (u < 0.0 || u > 1.0)
                return (0);

            Wektor q=s.cross(e1);
            float v = f * p.Kierunek.dot(q);

            if (v < 0.0 || u + v > 1.0)
                return (0);

            // at this stage we can compute t to find out where
            // the intersection point is on the line
            float t = f * e2.dot(q);

            if (t > 0.00001)
            { // ray intersection
                p.setOdleglosc(this, t);
                return (1);
            }

            else // this means that there is a line intersection
                // but not a ray intersection
                return (0);
        }

    }
}
